Deep middleware graphs widen the handler's response type (inference-budget
truncation), turning the response-write calls into runtime specialization
dispatch. _write_all_response!/write_response!/_write_h2_response! (and the
h2 streaming helper) now take @nospecialize(response) — one instance covers
every Response{B} — with an explicit isa chain over the body shapes in
write_response! and socket-union isa splits (with per-branch typeasserts,
which prevent the optimizer from tail-merging the branches back into one
dynamic call) at the h1 call sites.

With the response @nospecialize'd, every body read is abstract; concrete-first
isa chains (String / SubString{String} / Vector{UInt8} / BytesBody{Vector{UInt8}}
/ EmptyBody, then the abstract residuals) keep the common paths statically
dispatched under juliac --trim. The h2 fast path normalizes buffered bodies to
a concrete Vector{UInt8} once (one copy for string bodies; the frame writer
copies into the connection buffer anyway). Shared _body_close_any! replaces the
scattered widened close sites. Static messages in the unsupported-body throws
(typeof interpolation is show machinery — dynamic under trim).

…nospecialized write paths

Nospecializing the write path traded 4 boundary errors for ~90 interior ones
(every body read abstract) and the contract-tightening attempt broke range
serving. Instead: the write paths stay fully specialized per Response{B}
(clean under --trim, verified in isolation), and thin @noinline shims at the
two server boundaries isa-chain over the concrete Response shapes servers
produce — each branch dispatching into the specialized path, one residual
dynamic arm for exotic body types.

…im workloads

Review feedback (PR #1330): the per-site isa chains were fragile — easy to
miss a branch or let sites drift apart. Two @inline helpers are now the
single source of truth for the concrete shapes the server write paths
dispatch over:

- _with_body_narrowed(f, body): nothing / String / SubString{String} /
  Vector{UInt8} / EmptyBody / BytesBody{Vector{UInt8}} / AbstractBody
  (streaming residual) / fallback. Every branch re-narrows so f's call is
  statically dispatched. Used by _response_has_body (via shared
  _response_body_known_empty methods, also reused for the h2 body_empty
  check), the h1 chunked + exact-body writes, the h2 byte normalization,
  the h2 streaming writer, and _body_close_any!.
- _with_response_narrowed(f, response): the Response{B} equivalent, used
  by both _write_all_response_dyn! / _write_h2_response_dyn! shims.

The h2 streaming writer's isa ladder became per-shape _write_h2_body_shape!
methods (concrete b from the helper keeps their selection static).

New trim-compile workloads in the existing harness (both zero-tolerance,
compile + run under stock juliac):
- http_trim_server_response_shapes.jl: every supported body shape served
  and verified over the wire, through the widened-response shims.
- http_trim_server_router_registration.jl: Router construction + every
  register! form incl. middleware wrap and wildcard/param paths. Serving
  THROUGH the router stays uncovered pending the router-dispatch design.

Full-graph verifier count unchanged; h1+h2 server testsets green.

…trim coverage

- "trim_strict_bodies" Preference (default off): juliac --trim builds opt
  into strict narrowing — unknown request/response body shapes throw instead
  of taking the residual dynamic-dispatch fallback, letting the verifier
  prove the narrowing helpers fully static. A Preference rather than an ENV
  switch so flipping it invalidates the precompile cache (same pattern as
  StructUtils' trim_specialize).
- narrowing chains gain the BytesBody{Base.CodeUnits{UInt8,String}} arms —
  what the compat constructors produce for string bodies; previously these
  fell through to the AbstractBody/dynamic arms, which strict mode forbids
- response-shapes trim workload gains the 2-arg Response(status, body) form
  (the common error-response pattern), and the harness gains a strict-mode
  case: the same workload compiled in a temp project with the preference on
  (HTTP_TRIM_ONLY=strict selects just this case)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>